#include "Utils.h"
#include <QDebug>
#include <QRegularExpression>
#include <QProcess>
#include <QCryptographicHash>

QList<bool> quint16ToBoolList(quint16 value)
{
    QList<bool> boolList;
    for (int i = 0; i < 16; ++i) {
        // 将quint16右移i位，然后与1进行位与操作，结果为1则为true，为0则为false
        boolList.append((value >> i) & 1);
    }
    return boolList;
}


float quint16ToFloat(quint16 value1, quint16 value2)
{
    float fData = 0.0;
    quint32 u32Data = (static_cast<quint32>(value2) << 16) | value1;
    memcpy(&fData,&u32Data,sizeof (float));
    return fData;
}

QList<quint16> floatToQuint16(float value)
{
    QList<quint16>  quint16Datas;

    uint32_t intValue;
    memcpy(&intValue, &value, sizeof(value));

    // 分割成两个16位的部分
    quint16Datas << static_cast<quint16>(intValue & 0xFFFF) ;        // 取低16位
    quint16Datas << static_cast<quint16>((intValue >> 16) & 0xFFFF); // 取高16位
    return  quint16Datas;
}

Utils::Utils()
{

}


quint16 quint16ModifyBit(quint16 data, int bitIndex, bool bitValue)
{
    Q_ASSERT(bitIndex >= 0 && bitIndex < 16); // 确保位索引在合法范围内

    if (bitValue) {
        // 如果要设置的位是1，使用位或操作(|)来设置指定的位
        data |= (1 << bitIndex);
    } else {
        // 如果要设置的位是0，使用位与操作(&)和位取反操作(~)来清除指定的位
        data &= ~(1 << bitIndex);
    }
    return data;
}


QList<QPushButton*> findButtonsWithSpecificName(QWidget *parent, const QString &pattern)
{
    QList<QPushButton*> btns;

    // 使用QRegExp进行匹配
    QRegExp regex("\\b" + pattern + "\\b");

    // 递归查找所有QPushButton子控件
    QList<QPushButton*> allButtons = parent->findChildren<QPushButton*>();

    foreach (QPushButton *button, allButtons) {
        // 检查按钮的objectName是否包含特定模式
        if (regex.indexIn(button->objectName()) != -1) {
            qDebug() << "Found button with name containing" << pattern << ":" << button->objectName();
            btns << button;
        }
    }
    return  btns;
}


void setEnableAllChildWidgets(QWidget *parent, bool isEnable)
{
    if (!parent)
        return;

    // 禁用当前控件
    parent->setEnabled(isEnable);

    // 递归禁用所有子控件
    for (QObject* child : parent->children()) {
        if (QWidget* childWidget = qobject_cast<QWidget*>(child)) {
            setEnableAllChildWidgets(childWidget,isEnable);
        }
    }
}

QList<QPushButton *> findAllQPushButton(QWidget *parent)
{
    QList<QPushButton*> allButtons;
    if (!parent)
        return allButtons;

    // 检查当前控件是否为QPushButton
    QPushButton *button = qobject_cast<QPushButton*>(parent);
    if (button) {
        allButtons.append(button);
    }

    // 递归检查所有子控件
    allButtons << parent->findChildren<QPushButton*>();


    return allButtons;
}




quint16 boolListToQuint16(QList<bool> values)
{
    quint16 result = 0;
    if(values.size() != 16)
        return result;
    for (int i = 0; i < values.size(); ++i)
    {
        if (values.at(i)) {
            result |= (1 << i); // 如果boolList[i]为true，则在结果中的第i位设置为1
        }
    }

    return result;
}

QList<quint16> quint32toQuint16List(quint32 value)
{
    QList<quint16>  quint16Datas;

    // 分割成两个16位的部分
    quint16Datas << static_cast<quint16>(value & 0xFFFF) ;        // 取低16位
    quint16Datas << static_cast<quint16>((value >> 16) & 0xFFFF); // 取高16位
    return quint16Datas;
}

QString replaceFontSize(const QString &inputString, int increment)
{
    // 正则表达式，用于匹配形如 "font-size: 12px;" 的模式
    QRegularExpression regex("font-size:\\s*(\\d+)pt;");

    // 搜索匹配项
    QRegularExpressionMatch match = regex.match(inputString);

    if (match.hasMatch()) {
        // 获取匹配的数字部分
        QString numberStr = match.captured(1);
        // 将字符串转换为整数
        int fontSize = numberStr.toInt();
        // 增加字体大小
        fontSize += increment;
        // 替换原始字符串中的数字
        QString replacedString = inputString;
        replacedString.replace(match.capturedStart(1), match.capturedLength(1), QString::number(fontSize));
        return replacedString;
    } else {
        // 如果没有匹配项，返回原始字符串
        return inputString;
    }
}

QList<bool> invertBoolList(const QList<bool> &boolList)
{
    QList<bool> invertedList;
    for (bool value : boolList) {
        invertedList.append(!value);
    }
    return invertedList;
}


//比较两个QList<bool>
QMap<int, bool> compareQListBool(const QList<bool> &list1, const QList<bool> &list2)
{
    QMap<int, bool> result;

    // 如果两个列表的长度不同，返回空的QMap
    if (list1.size() != list2.size()) {
        return result;
    }

    // 遍历列表，比较对应的bool值
    for (int i = 0; i < list1.size(); ++i) {
        if (list1.at(i) != list2.at(i)) {
            // 如果值不同，将下标和第二个列表的值添加到结果中
            result.insert(i, list2.at(i));
        }
    }
    return result;
}

quint32 quint16ToQuint32(quint16 value1, quint16 value2)
{
    return (static_cast<quint32>(value2) << 16) | value1;
}

QString ByteArraytoQString16bitShow(QByteArray data)
{
    QString hexString = data.toHex();
    QString formattedHexString;

    // 遍历十六进制字符串，每两个字符之间插入一个空格
    for (int i = 0; i < hexString.length(); i += 2) {
        formattedHexString.append(hexString.mid(i, 2));
        if (i + 2 < hexString.length()) {
            formattedHexString.append(" ");
        }
    }
    return formattedHexString;
}

QList<bool> quint8ListToBoolList(QList<quint8> values)
{
    QList<bool> boolList;
    foreach (auto value, values) {
        for (int i = 0; i < 8; ++i) {
            // 将quint16右移i位，然后与1进行位与操作，结果为1则为true，为0则为false
            boolList.append((value >> i) & 1);
        }
    }
    return boolList;
}

QList<quint16> quint8ListToQuint16List(QList<quint8> values)
{
    QList<quint16> iList;
    for(int i = 0 ; i < values.size() ; i+=2)
    {
        iList.append( static_cast<quint16>(values.at(i+1) << 8) | values.at(i));
    }
    return iList;
}

quint16 calculateCRC(const QByteArray &data)
{
    quint16 crc = 0xFFFF;
    for (int i = 0; i < data.size(); i++) {
        crc ^= (quint16)(data.at(i) & 0xFF);
        for (int j = 0; j < 8; j++) {
            if (crc & 0x0001) {
                crc = (crc >> 1) ^ 0xA001;
            } else {
                crc = crc >> 1;
            }
        }
    }
    return crc;
}

quint16 swapBytes(quint16 value)
{
    return (value << 8) | (value >> 8);
}

QString printQuint16AsBytes(quint16 value)
{
    QByteArray byteArray;
    QDataStream stream(&byteArray, QIODevice::WriteOnly);
    stream.setByteOrder(QDataStream::LittleEndian); // 或 QDataStream::BigEndian，取决于你的需求
    stream << value;

    // 确保我们有两个字节
    Q_ASSERT(byteArray.size() == 2);

    // 打印每个字节
    return   QString::number(byteArray.at(0), 16) + " " + QString::number(byteArray.at(1), 16);
}

QString getHardDiskSerialNumber()
{
    QProcess process;
    process.start("wmic diskdrive get SerialNumber");
    process.waitForFinished();
    QString output = process.readAllStandardOutput();
    QStringList lines = output.split('\n');
    if (lines.size() > 1) { // 第一行是标题，第二行是数据
        return lines[1].trimmed();
    }
    return "";
}

QString calculateMD5(const QString &input)
{
    // 将QString转换为UTF-8编码的byte array
        QByteArray byteArray = input.toUtf8();

        // 创建QCryptographicHash对象，并指定MD5算法
        QCryptographicHash hash(QCryptographicHash::Md5);

        // 添加要哈希的数据
        hash.addData(byteArray);

        // 获取最终的哈希值
        QByteArray hashValue = hash.result();

        // 将哈希值转换为十六进制字符串
        QString md5String = hashValue.toHex();

        return md5String;
}
